home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / Broker.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  6KB  |  300 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysBroker.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    void HandleBrokerPort ( void );
  12.    *    void InstallBroker ( void );
  13.    *    void RemoveBroker ( void );
  14.    *
  15.    *      --- Lokale  Routinen ---
  16.    *
  17.    *    static void HandleBrokerInputEventMsg ( ULONG msgid );
  18.    *    static void HandleExchangeMsg ( ULONG msgid );
  19.    *    static void InstallHotKeys ( void );
  20.    *
  21.    * Bemerkungen:
  22.    *      Broker-Verwaltungsroutinen unter Verwendung der Commodities-Library.
  23.    *
  24.    * Erstellungsdatum:
  25.    *      07-Jul-93     Rolf Böhme
  26.    *
  27.    * Änderungen:
  28.    *      07-Jul-93     Rolf Böhme        Erstellung
  29.    *
  30.    ***************************************************************************
  31.  */
  32.  
  33. #include "RSys.h"
  34. #include "protos.h"
  35.  
  36.  /*
  37.   * Die Prozedur InstallHotKeys() bildet für alle zu
  38.   * installierenden HotKeys einen Filter und bindet
  39.   * diese dann in die Broker-Struktur ein.
  40.   */
  41. static void
  42. InstallHotKeys (void)
  43. {
  44.   int i;
  45.  
  46.   for (i = 0; i < HOTKEYS + 1; i++)
  47.     {
  48.       filter[i] = HotKey ((UBYTE *) & hotkey[i][0], broker_mp,
  49.               (long) (i + 1));
  50.       /*
  51.        * Falls kein Filter erzeugt werden konnte, wird eine
  52.        * Fehlermeldung ausgegeben und das Programm beendet.
  53.        */
  54.       if (NOT (filter[i]))
  55.     {
  56.       printf ("i = %d\n", i);
  57.       ErrorHandle ((char *) hotkey[i][0], BROKER_ERR, CREATE_FAIL, KILL);
  58.     }
  59.  
  60.       AttachCxObj (broker, filter[i]);
  61.     }
  62.  
  63.   return;
  64. }
  65.  
  66.  /*
  67.   * InstallBroker() öffnet die commodities.library,
  68.   * richtet einen MessagePort für die Nachrichten vom
  69.   * Broker ein, initialisiert ein Broker-
  70.   * Kontrollstruktur und startet den Broker.
  71.   */
  72. void
  73. InstallBroker (void)
  74. {
  75.  
  76. //  return;                     /*GMD */
  77.  
  78.   DPOS;
  79.   /*
  80.    * Ein Kommunikations-Port wird erzeugt.
  81.    */
  82.   if (broker_mp = CreatePort ((UBYTE *) "RSys-Broker-Port", 0L))
  83.     {
  84.       newbroker.nb_Port = broker_mp;
  85.       newbroker.nb_Pri = 0;
  86.  
  87.       /*
  88.        * Falls der Broker erzeugt werden konnte, werden die
  89.        * HotKeys installiert und der Broker gestartet.
  90.        */
  91.       if (broker = CxBroker (&newbroker, NULL))
  92.     InstallHotKeys ();
  93.       else
  94.     ErrorHandle (newbroker.nb_Name, BROKER_ERR, CREATE_FAIL, KILL);
  95.  
  96.       ActivateCxObj (broker, TRUE);
  97.     }
  98.   else
  99.     ErrorHandle ("RSys-Broker-Port", PORT_ERR, CREATE_FAIL, KILL);
  100.  
  101.   return;
  102. }
  103.  
  104.  /*
  105.   * RemoveBroker() entfernt alle mit dem Broker
  106.   * verbundenen Datenstrukturen aus dem System und
  107.   * schließt die commodities.library.
  108.   */
  109. void
  110. RemoveBroker (void)
  111. {
  112.   DPOS;
  113.  
  114.   if (broker)
  115.     DeleteCxObjAll (broker);
  116.   if (broker_mp)
  117.     DeletePort (broker_mp);
  118.  
  119.   return;
  120. }
  121.  
  122. static void
  123. HandleBrokerInputEventMsg (ULONG msgid)
  124. {
  125.   SCREEN *FindFrontPubScr (SCREEN *);
  126.  
  127.   SCREEN *activescr;
  128.   /*
  129.    * Dieses Feld von Funktionenzeigern enthält alle
  130.    * Funktionen, die entsprechend der MessageID
  131.    * ausgeführt werden.
  132.    */
  133.   void (*func[HOTKEYS]) (void) =
  134.   {CryptFile,
  135.    FindFile,
  136.    FormatDisk,
  137.    HunkStruct,
  138.    CRCSum,
  139.    SaveWindows,
  140.    DisplayFileRequest};
  141.  
  142.   int openit;
  143.  
  144.   /*
  145.    * Ist die MessageID 1, soll das RSys-Hauptfenster
  146.    * erscheinen.
  147.    */
  148.   if (msgid == 1)
  149.     {
  150.       /*
  151.        * Falls das Hauptfenster bereits offen ist, wird der
  152.        * nächst Public screen gesucht und versucht, RSys auf
  153.        * diesem Screen zu öffnen. War das erfolgreich, wird
  154.        * das ListView des Hauptfensters aktualisiert.
  155.        */
  156.       if (SysWnd)
  157.     {
  158.       activescr = SysWnd->WScreen;
  159.  
  160.       if (activescr != FindFrontPubScr (activescr))
  161.         {
  162.           CloseASysWindow (&SysWnd, &SysGList, &SysMenus);
  163.           CloseDownScreen ();
  164.  
  165.           OpenMainWindow ();
  166.           RefreshList (LastID);
  167.  
  168.           openit = CloseHelpOnScreen ();
  169.           OpenHelpOnScreen (openit);
  170.         }
  171.     }
  172.       else
  173.     {
  174.       /*
  175.        * Ist das Hauptfenster noch nicht geöffnet, wird es
  176.        * mit der Standardprozedur geöffnet und das ListView
  177.        * aktualisiert.
  178.        */
  179.       OpenMainWindow ();
  180.       RefreshList (LastID);
  181.  
  182.       openit = CloseHelpOnScreen ();
  183.       OpenHelpOnScreen (openit);
  184.     }
  185.     }
  186.   else
  187.     {
  188.       /*
  189.        * Ist die MessageID größer als 1, werden die
  190.        * entsprechenden Funktionen aus dem
  191.        * Funktionenzeigerfeld ausgeführt.  Ist das
  192.        * Hauptfenster noch nicht geöffnet worden, muß der
  193.        * Screen, auf dem das Fenster der jeweiligen
  194.        * Funktion geöffnet werden soll, mit SetupScreen()
  195.        * vorbereitet werden.
  196.        */
  197.       if (NOT (SysWnd))
  198.     if (SetupScreen ())
  199.       ErrorHandle ((char *) namebuffer, SCREEN_ERR, INFO_FAIL, NO_KILL);
  200.  
  201.       (*func[msgid - 2]) ();
  202.  
  203.       if (NOT (SysWnd))
  204.     CloseDownScreen ();
  205.     }
  206.  
  207.   return;
  208. }
  209.  
  210. static void
  211. HandleExchangeMsg (ULONG msgid)
  212. {
  213.   switch (msgid)
  214.     {
  215.       /*
  216.        * Der Broker von RSys soll ausgeschaltet werden.
  217.        */
  218.     case CXCMD_DISABLE:
  219.       ActivateCxObj (broker, 0L);
  220.       break;
  221.  
  222.       /*
  223.        * Der Broker von RSys soll eingeschaltet werden.
  224.        */
  225.     case CXCMD_ENABLE:
  226.       ActivateCxObj (broker, 1L);
  227.       break;
  228.  
  229.       /*
  230.        * RSys soll ohne Sicherheitsabfrage beendet werden.
  231.        */
  232.     case CXCMD_KILL:
  233.       quit (FALSE);
  234.       break;
  235.  
  236.     case CXCMD_UNIQUE:
  237.       /*
  238.        * Ein Programm versucht einen Broker mit dem Namen
  239.        * RSys einzurichten. Es erscheint eine Fehlermeldung.
  240.        */
  241.       ErrorHandle (newbroker.nb_Name, BROKER_ERR, DUPLICATE_FAIL, NO_KILL);
  242.       break;
  243.     }
  244.  
  245.   return;
  246. }
  247.  
  248.  /*
  249.   * HandleBrokerPort() verarbeitet alle Nachrichten,
  250.   * die am Broker port eintreffen.
  251.   */
  252. void
  253. HandleBrokerPort (void)
  254. {
  255.   CxMsg *msg;
  256.   ULONG msgid, msgtype;
  257.  
  258.   DPOS;
  259.   /*
  260.    * Alle Messages, die am Brokerport anliegen, werden
  261.    * bearbeitet.
  262.    */
  263.   while (msg = (CxMsg *) GetMsg (broker_mp))
  264.     {
  265.       /*
  266.        * Aus der Message werden die notwendigen Daten
  267.        * herauskopiert. Danach wird die Nachricht wieder
  268.        * so schnell wie möglich beantwortet, damit der
  269.        * Broker nicht wartet.
  270.        */
  271.       msgid = CxMsgID (msg);
  272.       msgtype = CxMsgType (msg);
  273.  
  274.       ReplyMsg ((MESSAGE *) msg);
  275.  
  276.       /*
  277.        * Entsprechend dem Typ der Nachricht werden
  278.        * verschiedene Aktionen ausgelöst.
  279.        */
  280.       switch (msgtype)
  281.     {
  282.       /*
  283.        * Es handelt sich um einen Inputevent.
  284.        */
  285.     case CXM_IEVENT:
  286.       HandleBrokerInputEventMsg (msgid);
  287.       break;
  288.  
  289.       /*
  290.        * Es ist eine Nachricht vom Programm Exchange.
  291.        */
  292.     case CXM_COMMAND:
  293.       HandleExchangeMsg (msgid);
  294.       break;
  295.     }
  296.     }
  297.  
  298.   return;
  299. }
  300.